//var jsReleases = require("node-releases/data/processed/envs.json");
//var agents = require("caniuse-lite/dist/unpacker/agents").agents;
//import { agents } from "../../caniuse-lite/src/unpacker/agents.js";
//var jsEOL = require(
//  "node-releases/data/release-schedule/release-schedule.json",
//);
//var path = require("path");
import { path, caniuselite } from "../deps.js";
//var e2c = require("electron-to-chromium/versions");

//var BrowserslistError = require("./error");
import BrowserslistError from "./error.js";
//var env = require("./node"); // Will load browser.js in webpack
import { node as env } from "./node.js";

var YEAR = 365.259641 * 24 * 60 * 60 * 1000;
var ANDROID_EVERGREEN_FIRST = 37;

var QUERY_OR = 1;
var QUERY_AND = 2;

function isVersionsMatch(versionA, versionB) {
  return (versionA + ".").indexOf(versionB + ".") === 0;
}

// function isEolReleased(name) {
//   var version = name.slice(1);
//   return jsReleases.some(function (i) {
//     return isVersionsMatch(i.version, version);
//   });
// }

function normalize(versions) {
  return versions.filter(function (version) {
    return typeof version === "string";
  });
}

function normalizeElectron(version) {
  var versionToUse = version;
  if (version.split(".").length === 3) {
    versionToUse = version
      .split(".")
      .slice(0, -1)
      .join(".");
  }
  return versionToUse;
}

function nameMapper(name) {
  return function mapName(version) {
    return name + " " + version;
  };
}

function getMajor(version) {
  return parseInt(version.split(".")[0]);
}

function getMajorVersions(released, number) {
  if (released.length === 0) return [];
  var majorVersions = uniq(released.map(getMajor));
  var minimum = majorVersions[majorVersions.length - number];
  if (!minimum) {
    return released;
  }
  var selected = [];
  for (var i = released.length - 1; i >= 0; i--) {
    if (minimum > getMajor(released[i])) break;
    selected.unshift(released[i]);
  }
  return selected;
}

function uniq(array) {
  var filtered = [];
  for (var i = 0; i < array.length; i++) {
    if (filtered.indexOf(array[i]) === -1) filtered.push(array[i]);
  }
  return filtered;
}

// Helpers

function fillUsage(result, name, data) {
  for (var i in data) {
    result[name + " " + i] = data[i];
  }
}

function generateFilter(sign, version) {
  version = parseFloat(version);
  if (sign === ">") {
    return function (v) {
      return parseFloat(v) > version;
    };
  } else if (sign === ">=") {
    return function (v) {
      return parseFloat(v) >= version;
    };
  } else if (sign === "<") {
    return function (v) {
      return parseFloat(v) < version;
    };
  } else {
    return function (v) {
      return parseFloat(v) <= version;
    };
  }
}

function generateSemverFilter(sign, version) {
  version = version.split(".").map(parseSimpleInt);
  version[1] = version[1] || 0;
  version[2] = version[2] || 0;
  if (sign === ">") {
    return function (v) {
      v = v.split(".").map(parseSimpleInt);
      return compareSemver(v, version) > 0;
    };
  } else if (sign === ">=") {
    return function (v) {
      v = v.split(".").map(parseSimpleInt);
      return compareSemver(v, version) >= 0;
    };
  } else if (sign === "<") {
    return function (v) {
      v = v.split(".").map(parseSimpleInt);
      return compareSemver(version, v) > 0;
    };
  } else {
    return function (v) {
      v = v.split(".").map(parseSimpleInt);
      return compareSemver(version, v) >= 0;
    };
  }
}

function parseSimpleInt(x) {
  return parseInt(x);
}

function compare(a, b) {
  if (a < b) return -1;
  if (a > b) return +1;
  return 0;
}

function compareSemver(a, b) {
  return (
    compare(parseInt(a[0]), parseInt(b[0])) ||
    compare(parseInt(a[1] || "0"), parseInt(b[1] || "0")) ||
    compare(parseInt(a[2] || "0"), parseInt(b[2] || "0"))
  );
}

// this follows the npm-like semver behavior
function semverFilterLoose(operator, range) {
  range = range.split(".").map(parseSimpleInt);
  if (typeof range[1] === "undefined") {
    range[1] = "x";
  }
  // ignore any patch version because we only return minor versions
  // range[2] = 'x'
  switch (operator) {
    case "<=":
      return function (version) {
        version = version.split(".").map(parseSimpleInt);
        return compareSemverLoose(version, range) <= 0;
      };
    default:
    case ">=":
      return function (version) {
        version = version.split(".").map(parseSimpleInt);
        return compareSemverLoose(version, range) >= 0;
      };
  }
}

// this follows the npm-like semver behavior
function compareSemverLoose(version, range) {
  if (version[0] !== range[0]) {
    return version[0] < range[0] ? -1 : +1;
  }
  if (range[1] === "x") {
    return 0;
  }
  if (version[1] !== range[1]) {
    return version[1] < range[1] ? -1 : +1;
  }
  return 0;
}

function resolveVersion(data, version) {
  if (data.versions.indexOf(version) !== -1) {
    return version;
  } else if (browserslist.versionAliases[data.name][version]) {
    return browserslist.versionAliases[data.name][version];
  } else {
    return false;
  }
}

function normalizeVersion(data, version) {
  var resolved = resolveVersion(data, version);
  if (resolved) {
    return resolved;
  } else if (data.versions.length === 1) {
    return data.versions[0];
  } else {
    return false;
  }
}

function filterByYear(since, context) {
  since = since / 1000;
  return Object.keys(caniuselite.agents).reduce(function (selected, name) {
    var data = byName(name, context);
    if (!data) return selected;
    var versions = Object.keys(data.releaseDate).filter(function (v) {
      return data.releaseDate[v] >= since;
    });
    return selected.concat(versions.map(nameMapper(data.name)));
  }, []);
}

function cloneData(data) {
  return {
    name: data.name,
    versions: data.versions,
    released: data.released,
    releaseDate: data.releaseDate,
  };
}

function mapVersions(data, map) {
  data.versions = data.versions.map(function (i) {
    return map[i] || i;
  });
  data.released = data.versions.map(function (i) {
    return map[i] || i;
  });
  var fixedDate = {};
  for (var i in data.releaseDate) {
    fixedDate[map[i] || i] = data.releaseDate[i];
  }
  data.releaseDate = fixedDate;
  return data;
}

function byName(name, context) {
  name = name.toLowerCase();
  name = browserslist.aliases[name] || name;
  if (context.mobileToDesktop && browserslist.desktopNames[name]) {
    var desktop = browserslist.data[browserslist.desktopNames[name]];
    if (name === "android") {
      return normalizeAndroidData(cloneData(browserslist.data[name]), desktop);
    } else {
      var cloned = cloneData(desktop);
      cloned.name = name;
      if (name === "op_mob") {
        cloned = mapVersions(cloned, { "10.0-10.1": "10" });
      }
      return cloned;
    }
  }
  return browserslist.data[name];
}

function normalizeAndroidVersions(androidVersions, chromeVersions) {
  var firstEvergreen = ANDROID_EVERGREEN_FIRST;
  var last = chromeVersions[chromeVersions.length - 1];
  return androidVersions
    .filter(function (version) {
      return /^(?:[2-4]\.|[34]$)/.test(version);
    })
    .concat(chromeVersions.slice(firstEvergreen - last - 1));
}

function normalizeAndroidData(android, chrome) {
  android.released = normalizeAndroidVersions(
    android.released,
    chrome.released,
  );
  android.versions = normalizeAndroidVersions(
    android.versions,
    chrome.versions,
  );
  return android;
}

function checkName(name, context) {
  var data = byName(name, context);
  if (!data) throw new BrowserslistError("Unknown browser " + name);
  return data;
}

function unknownQuery(query) {
  return new BrowserslistError(
    "Unknown browser query `" + query + "`. " +
      "Maybe you are using old Browserslist or made typo in query.",
  );
}

function filterAndroid(list, versions, context) {
  if (context.mobileToDesktop) return list;
  var released = browserslist.data.android.released;
  var last = released[released.length - 1];
  var diff = last - ANDROID_EVERGREEN_FIRST - versions;
  if (diff > 0) {
    return list.slice(-1);
  } else {
    return list.slice(diff - 1);
  }
}

/**
 * Resolves queries into a browser list.
 * @param {string|string[]} queries Queries to combine.
 * Either an array of queries or a long string of queries.
 * @param {object} [context] Optional arguments to
 * the select function in `queries`.
 * @returns {string[]} A list of browsers
 */
async function resolve(queries, context) {
  if (Array.isArray(queries)) {
    queries = flatten(queries.map(parse));
  } else {
    queries = parse(queries);
  }

  return queries.reduce(async function (result, query, index) {
    result = await result;
    var selection = query.queryString;

    var isExclude = selection.indexOf("not ") === 0;
    if (isExclude) {
      if (index === 0) {
        throw new BrowserslistError(
          "Write any browsers query (for instance, `defaults`) " +
            "before `" + selection + "`",
        );
      }
      selection = selection.slice(4);
    }

    for (var i = 0; i < QUERIES.length; i++) {
      var type = QUERIES[i];
      var match = selection.match(type.regexp);
      if (match) {
        var args = [context].concat(match.slice(1));
        var array = await Promise.resolve(
          type.select.apply(browserslist, args),
        );
        array = array.map(function (j) {
          var parts = j.split(" ");
          if (parts[1] === "0") {
            return parts[0] + " " + byName(parts[0], context).versions[0];
          } else {
            return j;
          }
        });

        switch (query.type) {
          case QUERY_AND:
            if (isExclude) {
              return result.filter(function (j) {
                return array.indexOf(j) === -1;
              });
            } else {
              return result.filter(function (j) {
                return array.indexOf(j) !== -1;
              });
            }
          case QUERY_OR:
          default:
            if (isExclude) {
              var filter = {};
              array.forEach(function (j) {
                filter[j] = true;
              });
              return result.filter(function (j) {
                return !filter[j];
              });
            }
            return result.concat(array);
        }
      }
    }

    throw unknownQuery(selection);
  }, Promise.resolve([]));
}

var cache = {};

/**
 * Return array of browsers by selection queries.
 *
 * @param {(string|string[])} [queries=browserslist.defaults] Browser queries.
 * @param {object} [opts] Options.
 * @param {string} [opts.path="."] Path to processed file.
 *                                 It will be used to find config files.
 * @param {string} [opts.env="production"] Processing environment.
 *                                         It will be used to take right
 *                                         queries from config file.
 * @param {string} [opts.config] Path to config file with queries.
 * @param {object} [opts.stats] Custom browser usage statistics
 *                              for "> 1% in my stats" query.
 * @param {boolean} [opts.ignoreUnknownVersions=false] Do not throw on unknown
 *                                                     version in direct query.
 * @param {boolean} [opts.dangerousExtend] Disable security checks
 *                                         for extend query.
 * @param {boolean} [opts.mobileToDesktop] Alias mobile browsers to the desktop
 *                                         version when Can I Use doesn't have
 *                                         data about the specified version.
 * @returns {string[]} Array with browser names in Can I Use.
 *
 * @example
 * browserslist('IE >= 10, IE 8') //=> ['ie 11', 'ie 10', 'ie 8']
 */
export async function browserslist(queries, opts) {
  if (typeof opts === "undefined") opts = {};

  if (typeof opts.path === "undefined") {
    opts.path = path.resolve ? path.resolve(".") : ".";
  }

  if (typeof queries === "undefined" || queries === null) {
    var config = browserslist.loadConfig(opts);
    if (config) {
      queries = config;
    } else {
      queries = browserslist.defaults;
    }
  }

  if (!(typeof queries === "string" || Array.isArray(queries))) {
    throw new BrowserslistError(
      "Browser queries must be an array or string. Got " + typeof queries + ".",
    );
  }

  var context = {
    ignoreUnknownVersions: opts.ignoreUnknownVersions,
    dangerousExtend: opts.dangerousExtend,
    mobileToDesktop: opts.mobileToDesktop,
  };

  env.oldDataWarning(browserslist.data);
  var stats = env.getStat(opts, browserslist.data);
  if (stats) {
    context.customUsage = {};
    for (var browser in stats) {
      fillUsage(context.customUsage, browser, stats[browser]);
    }
  }

  var cacheKey = JSON.stringify([queries, context]);
  if (cache[cacheKey]) return cache[cacheKey];

  var result = uniq(await resolve(queries, context)).sort(
    function (name1, name2) {
      name1 = name1.split(" ");
      name2 = name2.split(" ");
      if (name1[0] === name2[0]) {
        // assumptions on caniuse data
        // 1) version ranges never overlaps
        // 2) if version is not a range, it never contains `-`
        var version1 = name1[1].split("-")[0];
        var version2 = name2[1].split("-")[0];
        return compareSemver(version2.split("."), version1.split("."));
      } else {
        return compare(name1[0], name2[0]);
      }
    },
  );
  if (!Deno.env.BROWSERSLIST_DISABLE_CACHE) {
    cache[cacheKey] = result;
  }
  return result;
}

function parse(queries) {
  var qs = [];
  do {
    queries = doMatch(queries, qs);
  } while (queries);
  return qs;
}

function doMatch(string, qs) {
  var or = /^(?:,\s*|\s+or\s+)(.*)/i;
  var and = /^\s+and\s+(.*)/i;

  return find(string, function (parsed, n, max) {
    if (and.test(parsed)) {
      qs.unshift({ type: QUERY_AND, queryString: parsed.match(and)[1] });
      return true;
    } else if (or.test(parsed)) {
      qs.unshift({ type: QUERY_OR, queryString: parsed.match(or)[1] });
      return true;
    } else if (n === max) {
      qs.unshift({ type: QUERY_OR, queryString: parsed.trim() });
      return true;
    }
    return false;
  });
}

function find(string, predicate) {
  for (var n = 1, max = string.length; n <= max; n++) {
    var parsed = string.substr(-n, n);
    if (predicate(parsed, n, max)) {
      return string.slice(0, -n);
    }
  }
  return "";
}

function flatten(array) {
  if (!Array.isArray(array)) return [array];
  return array.reduce(function (a, b) {
    return a.concat(flatten(b));
  }, []);
}

// Will be filled by Can I Use data below
browserslist.data = {};
browserslist.usage = {
  global: {},
  custom: null,
};

// Default browsers query
browserslist.defaults = [
  "> 0.5%",
  "last 2 versions",
  "Firefox ESR",
  "not dead",
];

// Browser names aliases
browserslist.aliases = {
  fx: "firefox",
  ff: "firefox",
  ios: "ios_saf",
  explorer: "ie",
  blackberry: "bb",
  explorermobile: "ie_mob",
  operamini: "op_mini",
  operamobile: "op_mob",
  chromeandroid: "and_chr",
  firefoxandroid: "and_ff",
  ucandroid: "and_uc",
  qqandroid: "and_qq",
};

// Can I Use only provides a few versions for some browsers (e.g. and_chr).
// Fallback to a similar browser for unknown versions
browserslist.desktopNames = {
  and_chr: "chrome",
  and_ff: "firefox",
  ie_mob: "ie",
  op_mob: "opera",
  android: "chrome", // has extra processing logic
};

// Aliases to work with joined versions like `ios_saf 7.0-7.1`
browserslist.versionAliases = {};

browserslist.clearCaches = env.clearCaches;
browserslist.parseConfig = env.parseConfig;
browserslist.readConfig = env.readConfig;
browserslist.findConfig = env.findConfig;
browserslist.loadConfig = env.loadConfig;

/**
 * Return browsers market coverage.
 *
 * @param {string[]} browsers Browsers names in Can I Use.
 * @param {string|object} [stats="global"] Which statistics should be used.
 *                                         Country code or custom statistics.
 *                                         Pass `"my stats"` to load statistics
 *                                         from Browserslist files.
 *
 * @return {number} Total market coverage for all selected browsers.
 *
 * @example
 * browserslist.coverage(browserslist('> 1% in US'), 'US') //=> 83.1
 */
browserslist.coverage = function (browsers, stats) {
  var data;
  if (typeof stats === "undefined") {
    data = browserslist.usage.global;
  } else if (stats === "my stats") {
    var opts = {};
    opts.path = path.resolve ? path.resolve(".") : ".";
    var customStats = env.getStat(opts);
    if (!customStats) {
      throw new BrowserslistError("Custom usage statistics was not provided");
    }
    data = {};
    for (var browser in customStats) {
      fillUsage(data, browser, customStats[browser]);
    }
  } else if (typeof stats === "string") {
    if (stats.length > 2) {
      stats = stats.toLowerCase();
    } else {
      stats = stats.toUpperCase();
    }
    env.loadCountry(browserslist.usage, stats, browserslist.data);
    data = browserslist.usage[stats];
  } else {
    if ("dataByBrowser" in stats) {
      stats = stats.dataByBrowser;
    }
    data = {};
    for (var name in stats) {
      for (var version in stats[name]) {
        data[name + " " + version] = stats[name][version];
      }
    }
  }

  return browsers.reduce(function (all, i) {
    var usage = data[i];
    if (usage === undefined) {
      usage = data[i.replace(/ \S+$/, " 0")];
    }
    return all + (usage || 0);
  }, 0);
};

var QUERIES = [
  {
    regexp: /^last\s+(\d+)\s+major\s+versions?$/i,
    select: function (context, versions) {
      return Object.keys(caniuselite.agents).reduce(function (selected, name) {
        var data = byName(name, context);
        if (!data) return selected;
        var list = getMajorVersions(data.released, versions);
        list = list.map(nameMapper(data.name));
        if (data.name === "android") {
          list = filterAndroid(list, versions, context);
        }
        return selected.concat(list);
      }, []);
    },
  },
  {
    regexp: /^last\s+(\d+)\s+versions?$/i,
    select: function (context, versions) {
      return Object.keys(caniuselite.agents).reduce(function (selected, name) {
        var data = byName(name, context);
        if (!data) return selected;
        var list = data.released.slice(-versions);
        list = list.map(nameMapper(data.name));
        if (data.name === "android") {
          list = filterAndroid(list, versions, context);
        }
        return selected.concat(list);
      }, []);
    },
  },
  /*
  {
    regexp: /^last\s+(\d+)\s+electron\s+major\s+versions?$/i,
    select: function (context, versions) {
      var validVersions = getMajorVersions(
        Object.keys(e2c).reverse(),
        versions,
      );
      return validVersions.map(function (i) {
        return "chrome " + e2c[i];
      });
    },
  },
  */
  {
    regexp: /^last\s+(\d+)\s+(\w+)\s+major\s+versions?$/i,
    select: function (context, versions, name) {
      var data = checkName(name, context);
      var validVersions = getMajorVersions(data.released, versions);
      var list = validVersions.map(nameMapper(data.name));
      if (data.name === "android") {
        list = filterAndroid(list, versions, context);
      }
      return list;
    },
  },
  /*
  {
    regexp: /^last\s+(\d+)\s+electron\s+versions?$/i,
    select: function (context, versions) {
      return Object.keys(e2c).reverse().slice(-versions).map(function (i) {
        return "chrome " + e2c[i];
      });
    },
  },
  */
  {
    regexp: /^last\s+(\d+)\s+(\w+)\s+versions?$/i,
    select: function (context, versions, name) {
      var data = checkName(name, context);
      var list = data.released.slice(-versions).map(nameMapper(data.name));
      if (data.name === "android") {
        list = filterAndroid(list, versions, context);
      }
      return list;
    },
  },
  {
    regexp: /^unreleased\s+versions$/i,
    select: function (context) {
      return Object.keys(caniuselite.agents).reduce(function (selected, name) {
        var data = byName(name, context);
        if (!data) return selected;
        var list = data.versions.filter(function (v) {
          return data.released.indexOf(v) === -1;
        });
        list = list.map(nameMapper(data.name));
        return selected.concat(list);
      }, []);
    },
  },
  {
    regexp: /^unreleased\s+electron\s+versions?$/i,
    select: function () {
      return [];
    },
  },
  {
    regexp: /^unreleased\s+(\w+)\s+versions?$/i,
    select: function (context, name) {
      var data = checkName(name, context);
      return data.versions.filter(function (v) {
        return data.released.indexOf(v) === -1;
      }).map(nameMapper(data.name));
    },
  },
  {
    regexp: /^last\s+(\d*.?\d+)\s+years?$/i,
    select: function (context, years) {
      return filterByYear(Date.now() - YEAR * years, context);
    },
  },
  {
    regexp: /^since (\d+)(?:-(\d+))?(?:-(\d+))?$/i,
    select: function (context, year, month, date) {
      year = parseInt(year);
      month = parseInt(month || "01") - 1;
      date = parseInt(date || "01");
      return filterByYear(Date.UTC(year, month, date, 0, 0, 0), context);
    },
  },
  {
    regexp: /^(>=?|<=?)\s*(\d*\.?\d+)%$/,
    select: function (context, sign, popularity) {
      popularity = parseFloat(popularity);
      var usage = browserslist.usage.global;
      return Object.keys(usage).reduce(function (result, version) {
        if (sign === ">") {
          if (usage[version] > popularity) {
            result.push(version);
          }
        } else if (sign === "<") {
          if (usage[version] < popularity) {
            result.push(version);
          }
        } else if (sign === "<=") {
          if (usage[version] <= popularity) {
            result.push(version);
          }
        } else if (usage[version] >= popularity) {
          result.push(version);
        }
        return result;
      }, []);
    },
  },
  {
    regexp: /^(>=?|<=?)\s*(\d*\.?\d+)%\s+in\s+my\s+stats$/,
    select: function (context, sign, popularity) {
      popularity = parseFloat(popularity);
      if (!context.customUsage) {
        throw new BrowserslistError("Custom usage statistics was not provided");
      }
      var usage = context.customUsage;
      return Object.keys(usage).reduce(function (result, version) {
        if (sign === ">") {
          if (usage[version] > popularity) {
            result.push(version);
          }
        } else if (sign === "<") {
          if (usage[version] < popularity) {
            result.push(version);
          }
        } else if (sign === "<=") {
          if (usage[version] <= popularity) {
            result.push(version);
          }
        } else if (usage[version] >= popularity) {
          result.push(version);
        }
        return result;
      }, []);
    },
  },
  {
    regexp: /^(>=?|<=?)\s*(\d*\.?\d+)%\s+in\s+(\S+)\s+stats$/,
    select: function (context, sign, popularity, name) {
      popularity = parseFloat(popularity);
      var stats = env.loadStat(context, name, browserslist.data);
      if (stats) {
        context.customUsage = {};
        for (var browser in stats) {
          fillUsage(context.customUsage, browser, stats[browser]);
        }
      }
      if (!context.customUsage) {
        throw new BrowserslistError("Custom usage statistics was not provided");
      }
      var usage = context.customUsage;
      return Object.keys(usage).reduce(function (result, version) {
        if (sign === ">") {
          if (usage[version] > popularity) {
            result.push(version);
          }
        } else if (sign === "<") {
          if (usage[version] < popularity) {
            result.push(version);
          }
        } else if (sign === "<=") {
          if (usage[version] <= popularity) {
            result.push(version);
          }
        } else if (usage[version] >= popularity) {
          result.push(version);
        }
        return result;
      }, []);
    },
  },
  {
    regexp: /^(>=?|<=?)\s*(\d*\.?\d+)%\s+in\s+((alt-)?\w\w)$/,
    select: function (context, sign, popularity, place) {
      popularity = parseFloat(popularity);
      if (place.length === 2) {
        place = place.toUpperCase();
      } else {
        place = place.toLowerCase();
      }
      env.loadCountry(browserslist.usage, place, browserslist.data);
      var usage = browserslist.usage[place];
      return Object.keys(usage).reduce(function (result, version) {
        if (sign === ">") {
          if (usage[version] > popularity) {
            result.push(version);
          }
        } else if (sign === "<") {
          if (usage[version] < popularity) {
            result.push(version);
          }
        } else if (sign === "<=") {
          if (usage[version] <= popularity) {
            result.push(version);
          }
        } else if (usage[version] >= popularity) {
          result.push(version);
        }
        return result;
      }, []);
    },
  },
  {
    regexp: /^cover\s+(\d*\.?\d+)%(\s+in\s+(my\s+stats|(alt-)?\w\w))?$/,
    select: function (context, coverage, statMode) {
      coverage = parseFloat(coverage);
      var usage = browserslist.usage.global;
      if (statMode) {
        if (statMode.match(/^\s+in\s+my\s+stats$/)) {
          if (!context.customUsage) {
            throw new BrowserslistError(
              "Custom usage statistics was not provided",
            );
          }
          usage = context.customUsage;
        } else {
          var match = statMode.match(/\s+in\s+((alt-)?\w\w)/);
          var place = match[1];
          if (place.length === 2) {
            place = place.toUpperCase();
          } else {
            place = place.toLowerCase();
          }
          env.loadCountry(browserslist.usage, place, browserslist.data);
          usage = browserslist.usage[place];
        }
      }
      var versions = Object.keys(usage).sort(function (a, b) {
        return usage[b] - usage[a];
      });
      var coveraged = 0;
      var result = [];
      var version;
      for (var i = 0; i <= versions.length; i++) {
        version = versions[i];
        if (usage[version] === 0) break;
        coveraged += usage[version];
        result.push(version);
        if (coveraged >= coverage) break;
      }
      return result;
    },
  },
  /*
  {
    regexp: /^electron\s+([\d.]+)\s*-\s*([\d.]+)$/i,
    select: function (context, from, to) {
      var fromToUse = normalizeElectron(from);
      var toToUse = normalizeElectron(to);
      if (!e2c[fromToUse]) {
        throw new BrowserslistError("Unknown version " + from + " of electron");
      }
      if (!e2c[toToUse]) {
        throw new BrowserslistError("Unknown version " + to + " of electron");
      }
      from = parseFloat(from);
      to = parseFloat(to);
      return Object.keys(e2c).filter(function (i) {
        var parsed = parseFloat(i);
        return parsed >= from && parsed <= to;
      }).map(function (i) {
        return "chrome " + e2c[i];
      });
    },
  },
  */
  /*
  {
    regexp: /^node\s+([\d.]+)\s*-\s*([\d.]+)$/i,
    select: function (context, from, to) {
      var nodeVersions = jsReleases.filter(function (i) {
        return i.name === "nodejs";
      }).map(function (i) {
        return i.version;
      });
      var semverRegExp = /^(0|[1-9]\d*)(\.(0|[1-9]\d*)){0,2}$/;
      if (!semverRegExp.test(from)) {
        throw new BrowserslistError(
          "Unknown version " + from + " of Node.js",
        );
      }
      if (!semverRegExp.test(to)) {
        throw new BrowserslistError(
          "Unknown version " + to + " of Node.js",
        );
      }
      return nodeVersions
        .filter(semverFilterLoose(">=", from))
        .filter(semverFilterLoose("<=", to))
        .map(function (v) {
          return "node " + v;
        });
    },
  },
  */
  {
    regexp: /^(\w+)\s+([\d.]+)\s*-\s*([\d.]+)$/i,
    select: function (context, name, from, to) {
      var data = checkName(name, context);
      from = parseFloat(normalizeVersion(data, from) || from);
      to = parseFloat(normalizeVersion(data, to) || to);
      function filter(v) {
        var parsed = parseFloat(v);
        return parsed >= from && parsed <= to;
      }
      return data.released.filter(filter).map(nameMapper(data.name));
    },
  },
  /*
  {
    regexp: /^electron\s*(>=?|<=?)\s*([\d.]+)$/i,
    select: function (context, sign, version) {
      var versionToUse = normalizeElectron(version);
      return Object.keys(e2c)
        .filter(generateFilter(sign, versionToUse))
        .map(function (i) {
          return "chrome " + e2c[i];
        });
    },
  },
  */
  /*
  {
    regexp: /^node\s*(>=?|<=?)\s*([\d.]+)$/i,
    select: function (context, sign, version) {
      var nodeVersions = jsReleases.filter(function (i) {
        return i.name === "nodejs";
      }).map(function (i) {
        return i.version;
      });
      return nodeVersions
        .filter(generateSemverFilter(sign, version))
        .map(function (v) {
          return "node " + v;
        });
    },
  },
  */
  {
    regexp: /^(\w+)\s*(>=?|<=?)\s*([\d.]+)$/,
    select: function (context, name, sign, version) {
      var data = checkName(name, context);
      var alias = browserslist.versionAliases[data.name][version];
      if (alias) {
        version = alias;
      }
      return data.released
        .filter(generateFilter(sign, version))
        .map(function (v) {
          return data.name + " " + v;
        });
    },
  },
  {
    regexp: /^(firefox|ff|fx)\s+esr$/i,
    select: function () {
      return ["firefox 68"];
    },
  },
  {
    regexp: /(operamini|op_mini)\s+all/i,
    select: function () {
      return ["op_mini all"];
    },
  },
  /*
  {
    regexp: /^electron\s+([\d.]+)$/i,
    select: function (context, version) {
      var versionToUse = normalizeElectron(version);
      var chrome = e2c[versionToUse];
      if (!chrome) {
        throw new BrowserslistError(
          "Unknown version " + version + " of electron",
        );
      }
      return ["chrome " + chrome];
    },
  },
  */
  /*
  {
    regexp: /^node\s+(\d+(\.\d+)?(\.\d+)?)$/i,
    select: function (context, version) {
      var nodeReleases = jsReleases.filter(function (i) {
        return i.name === "nodejs";
      });
      var matched = nodeReleases.filter(function (i) {
        return isVersionsMatch(i.version, version);
      });
      if (matched.length === 0) {
        if (context.ignoreUnknownVersions) {
          return [];
        } else {
          throw new BrowserslistError(
            "Unknown version " + version + " of Node.js",
          );
        }
      }
      return ["node " + matched[matched.length - 1].version];
    },
  },
  */
  {
    regexp: /^current\s+node$/i,
    select: function (context) {
      return [env.currentNode(resolve, context)];
    },
  },
  /*
  {
    regexp: /^maintained\s+node\s+versions$/i,
    select: function (context) {
      var now = Date.now();
      var queries = Object.keys(jsEOL).filter(function (key) {
        return now < Date.parse(jsEOL[key].end) &&
          now > Date.parse(jsEOL[key].start) &&
          isEolReleased(key);
      }).map(function (key) {
        return "node " + key.slice(1);
      });
      return resolve(queries, context);
    },
  },
  */
  {
    regexp: /^phantomjs\s+1.9$/i,
    select: function () {
      return ["safari 5"];
    },
  },
  {
    regexp: /^phantomjs\s+2.1$/i,
    select: function () {
      return ["safari 6"];
    },
  },
  {
    regexp: /^(\w+)\s+(tp|[\d.]+)$/i,
    select: function (context, name, version) {
      if (/^tp$/i.test(version)) version = "TP";
      var data = checkName(name, context);
      var alias = normalizeVersion(data, version);
      if (alias) {
        version = alias;
      } else {
        if (version.indexOf(".") === -1) {
          alias = version + ".0";
        } else {
          alias = version.replace(/\.0$/, "");
        }
        alias = normalizeVersion(data, alias);
        if (alias) {
          version = alias;
        } else if (context.ignoreUnknownVersions) {
          return [];
        } else {
          throw new BrowserslistError(
            "Unknown version " + version + " of " + name,
          );
        }
      }
      return [data.name + " " + version];
    },
  },
  {
    regexp: /^extends (.+)$/i,
    select: async function (context, name) {
      return resolve(await env.loadQueries(context, name), context);
    },
  },
  {
    regexp: /^defaults$/i,
    select: function (context) {
      return resolve(browserslist.defaults, context);
    },
  },
  {
    regexp: /^dead$/i,
    select: function (context) {
      var dead = [
        "ie <= 10",
        "ie_mob <= 11",
        "bb <= 10",
        "op_mob <= 12.1",
        "samsung 4",
      ];
      return resolve(dead, context);
    },
  },
  {
    regexp: /^(\w+)$/i,
    select: function (context, name) {
      if (byName(name, context)) {
        throw new BrowserslistError(
          "Specify versions in Browserslist query for browser " + name,
        );
      } else {
        throw unknownQuery(name);
      }
    },
  },
];

// Get and convert Can I Use data

(function () {
  for (var name in caniuselite.agents) {
    var browser = caniuselite.agents[name];
    browserslist.data[name] = {
      name: name,
      versions: normalize(caniuselite.agents[name].versions),
      released: normalize(caniuselite.agents[name].versions.slice(0, -3)),
      releaseDate: caniuselite.agents[name].release_date,
    };
    fillUsage(browserslist.usage.global, name, browser.usage_global);

    browserslist.versionAliases[name] = {};
    for (var i = 0; i < browser.versions.length; i++) {
      var full = browser.versions[i];
      if (!full) continue;

      if (full.indexOf("-") !== -1) {
        var interval = full.split("-");
        for (var j = 0; j < interval.length; j++) {
          browserslist.versionAliases[name][interval[j]] = full;
        }
      }
    }
  }
}());
